Floating and tiling window managers
In the X Window System, the window manager is that piece of software that places
your windows and allows you to move them, resize them, hide them, etc. If your windows
have titles on top of them, with buttons to close them or reduce them, it is thanks to
the window manager. There are two major types of window managers:
- Floating window managers
- They are the most usual window managers, that allow you to place
an size your windows freely on the screen, in a way where they are
independent of each other, possibly overlapping, just as you would
be able to place sheets of paper on your desk.
- Tiling window managers
- They are a more elitist type of window manager, that adjust the
size and position of the windows so there is no overlapping and no
space lost between windows, thus tiling the screen.
The frontier between these two types is not very tight, because some
floating window managers have limited tiling features, and almost all
the tiling window manager have floating modes for programs that are not
adapted to tiling.
For what it is worth, here is a report on my experience with three tiling window
managers. Perhaps it may help people that are still hesitating to switch to tiling
window management?Using tiling window managers
Five years ago I switched to tiling window management, feeling that
managing windows was the window manager's job (a quote from larswm).
At that time, I started using
wmii, then switched to
awesome, and now I am
trying
i3.
For people in a hurry, here is a comparative table:
| wmii | awesome | i3 |
|---|
| Configuration |
Shell script |
Lua script |
config file |
|---|
| Scriptability |
any language, 9P-based |
Lua, API-based |
any language, socket-based |
|---|
| Layout |
simple, column-based |
automatic layout-based |
flexible, manual tiling-based |
|---|
| Multi-monitor |
sucks |
OK |
OK |
|---|
| Modern stuff |
|
XCB,
Xft,
notification area, dock windows |
XCB,
Xft,
notification area |
|---|
| Special features |
- tag-based workspace system
|
- XDG
convention to locate the config file
- real framework for customization
|
|
|---|
wmii
wmii is a rather
minimalist window manager which used to be part of the
suckless project, but is now hosted
at Google Code and seems to have lost all its documentation during the
move (why is it that all the software I have seen hosted at Google Code
or worst, at Launchpad, have almost not documentation, and never, ever a
single screenshot?).
It uses a
column-based layout: you place windows in a number
of columns, and for each column you can choose either vertical split,
stacking or full column mode. This system is very simple to control
flexible enough for most situations, but it does not allow for arbitrary
tiling.
It is
fully scriptable in any language, in an interesting
way: it exposes all its functions on a 9P virtual filesystem. In fact,
wmii itself only implements window management functions, and all the
user interaction logic takes place in a distinct script which calls that
functions using that 9P filesystem. wmii comes with a default script,
written in shell, which makes it a bit hard to extend, and slow if you
start calling external programs such as grep, sed and co. You can script
it in any language you like however, and there are some already made
implementations in Ruby and Python IIRC.
A special feature of wmii is that its workspaces are in fact
tags, and that you can tag a window so that it will appear in
several ones. While this is interesting, in practice I did not find much
use for that feature.
It is explicitly minimalist, and the developers used to impose
themselves a limit on its numbers of lines of codes (not sure if this is
still true with the switch to Google Code). While I was using it, it had
no notification area, no support for
Xft
fonts and it sucked with multiple monitors, which is the reason I
switched to awesome.
awesome
awesome is a very
flexible window manager that provides advanced automatic layouts. It has
become quite popular, and it has a very well documented wiki. It is not
officially a tiling window manager but a framework window manager, and
to emphasize on that it start in floating mode by default. I think most
people use it in tiling mode however.
It uses
automatic layouts, that place your windows according
to rules, for instance the fair layout, which tiles in columns and
rows so that each window occupies a similar space. Thanks to that
automation, this system is very easy to control and to get used to, and
although it certainly does not allow arbitrary tiling, you can cycle
between several available layouts which are suitable for most
situations (most of them are entirely automatic, but some have
parameters you can modify, such as the number and width of columns), and
if you miss one, I think you can even code your own.
It is
fully scriptable using the Lua language. In fact, just
as wmii, the user interaction logic is defined in the configuration
file, which allows efficient customization. The Lua API is fully
documented, and there is a series of useful libraries to extend the
basic configuration in any way you like, which is why awesome calls
itself a framework window manager .
It is not designed to be minimalist, and it
implements some
modern stuff, such as using
XCB
rather than Xlib, a
notification area, and specific support for dock or utility-type windows
such as GIMP's tools.
i3
i3 is a window manager inspired by
wmii, although they do not have much in common in my opinion. for what I
have seen, I think it would be closer the defunct Ion.
It uses a layout based on manual splitting: as you open windows you
can choose to split an existing window either vertically or
horizontally, leading to arbitrarily complex layouts. In addition to
that you can tab or stack windows in containers instead of splitting
them. This system is very flexible but it requires more user
intervention.
In its standard mode of operation, i3 is simply configured in a
regular way, which allows to customize the user interaction but not to
script it in an arbitrary way. It offers an IPC system that can be used
for that however, by the mean of a Unix socket, so it can actually be
scripted in any language too if needed, although this possibility is
probably not as popular and easy as with wmii and awesome.
It implements modern features such as
XCB,
a notification area and a
powerful status bar that uses the standard output of a dedicated program
that is easy to replace by your own if you need.
My current 
) that such activity can be considered as volunteering but I eventually did it!
So last Thursday and Friday were days I could spent working on my packages and other stuff related to Debian 
This is my monthly summary of my Debian related activities. If you re among the people who 
When you start using Linux' logical volume manager, one of the first question
you have to answer is: what name will you give to your volume group? The usual
answer is: vg1, vg2, etc. Although it does not bear any specific meaning, this
naming convention is simple and seems functional enough.
In fact, this is a bad idea, which can have nasty consequences on the long
term. Here is why: one day, your computer will eventually give out. To save your
precious data, you will remove its drives and plug them into another computer.
If you are using LVM with the same naming convention on that second computer, you
will then get a name conflict, which will prevent you from seeing the volume
group you want to recover.
The solution is to name volume groups uniquely across all your computers,
and if possible other people's. An elegant way to achieve this is to use your
host names as a basis. For instance, on a machine called Pi acolada , you would
name a single volume group pinacolada , or two volume groups pinacolada1 and
pinacolada2 . Or perhaps vg-pinacolada0 or whatever, you get the idea.
To this end, la Quadrature will 
